home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / DebugGraphics.java < prev    next >
Text File  |  1998-06-30  |  37KB  |  1,075 lines
  1. /*
  2.  * @(#)DebugGraphics.java    1.8 98/01/30
  3.  *
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  *
  19.  */
  20.  
  21. package com.sun.java.swing;
  22.  
  23. import java.awt.*;
  24. import java.awt.image.*;
  25.  
  26. /** Graphics subclass supporting graphics debugging. Overrides most methods
  27.   * from Graphics.  DebugGraphics objects are rarely created by hand.  They
  28.   * are most frequently created automatically when a JComponent's
  29.   * debugGraphicsOptions are changed using the setDebugGraphicsOptions()
  30.   * method.
  31.   *
  32.   * @see JComponent#setDebugGraphicsOptions
  33.   *
  34.   * @version 1.8 01/30/98
  35.   * @author Dave Karlton
  36.   */
  37. public class DebugGraphics extends Graphics {
  38.     Graphics                    graphics;
  39.     Image                       buffer;
  40.     int                         debugOptions;
  41.     int                         graphicsID = graphicsCount++;
  42.     int                         xOffset, yOffset;
  43.     private static int          graphicsCount = 0;
  44.  
  45.     /** Log graphics operations. */
  46.     public static final int     LOG_OPTION   = 1 << 0;
  47.     /** Flash graphics operations. */
  48.     public static final int     FLASH_OPTION = 1 << 1;
  49.     /** Show buffered operations in a seperate Frame. */
  50.     public static final int     BUFFERED_OPTION = 1 << 2;
  51.     /** Don't debug graphics operations. */
  52.     public static final int     NONE_OPTION = -1;
  53.  
  54.     public DebugGraphics() {
  55.         super();
  56.         buffer = null;
  57.         xOffset = yOffset = 0;
  58.     }
  59.  
  60.     /** Handle on AWT Graphics
  61.       */
  62.     public DebugGraphics(Graphics graphics, JComponent component) {
  63.         this(graphics);
  64.         setDebugOptions(component.shouldDebugGraphics());
  65.     }
  66.  
  67.     public DebugGraphics(Graphics graphics) {
  68.         this();
  69.         this.graphics = graphics;
  70.     }
  71.  
  72.     public Graphics create() {
  73.         DebugGraphics debugGraphics;
  74.  
  75.         debugGraphics = new DebugGraphics();
  76.         debugGraphics.graphics = graphics.create();
  77.         debugGraphics.debugOptions = debugOptions;
  78.         debugGraphics.buffer = buffer;
  79.  
  80.         return debugGraphics;
  81.     }
  82.  
  83.     public Graphics create(int x, int y, int width, int height) {
  84.         DebugGraphics debugGraphics;
  85.  
  86.         debugGraphics = new DebugGraphics();
  87.         debugGraphics.graphics = 
  88.             SwingGraphics.createGraphics(graphics, x, y, width, height);
  89.         debugGraphics.debugOptions = debugOptions;
  90.         debugGraphics.buffer = buffer;
  91.         debugGraphics.xOffset = xOffset + x;
  92.         debugGraphics.yOffset = yOffset + y;
  93.  
  94.         return debugGraphics;
  95.     }
  96.  
  97.     /** Sets the Color used to flash drawing operations.
  98.       */
  99.     public static void setFlashColor(Color flashColor) {
  100.         info().flashColor = flashColor;
  101.     }
  102.  
  103.     /** Returns the Color used to flash drawing operations.
  104.       * @see #setFlashColor
  105.       */
  106.     public static Color flashColor() {
  107.         return info().flashColor;
  108.     }
  109.  
  110.     /** Sets the time delay of drawing operation flashing.
  111.       */
  112.     public static void setFlashTime(int flashTime) {
  113.         info().flashTime = flashTime;
  114.     }
  115.  
  116.     /** Returns the time delay of drawing operation flashing.
  117.       * @see #setFlashTime
  118.       */
  119.     public static int flashTime() {
  120.         return info().flashTime;
  121.     }
  122.  
  123.     /** Sets the number of times that drawing operations will flash.
  124.       */
  125.     public static void setFlashCount(int flashCount) {
  126.         info().flashCount = flashCount;
  127.     }
  128.  
  129.     /** Returns the number of times that drawing operations will flash.
  130.       * @see #setFlashCount
  131.       */
  132.     public static int flashCount() {
  133.         return info().flashCount;
  134.     }
  135.  
  136.     /** Sets the stream to which the DebugGraphics logs drawing operations.
  137.       */
  138.     public static void setLogStream(java.io.PrintStream stream) {
  139.         info().stream = stream;
  140.     }
  141.  
  142.     /** Returns the stream to which the DebugGraphics logs drawing operations.
  143.       * @see #setLogStream
  144.       */
  145.     public static java.io.PrintStream logStream() {
  146.         return info().stream;
  147.     }
  148.  
  149.     /** Sets the Font used for text drawing operations.
  150.       */
  151.     public void setFont(Font aFont) {
  152.         if (debugLog()) {
  153.             info().log(toShortString() + " Setting font: " + aFont);
  154.         }
  155.         graphics.setFont(aFont);
  156.     }
  157.  
  158.     /** Returns the Font used for text drawing operations.
  159.       * @see #setFont
  160.       */
  161.     public Font getFont() {
  162.         return graphics.getFont();
  163.     }
  164.  
  165.     /** Sets the color to be used for drawing and filling lines and shapes.
  166.       */
  167.     public void setColor(Color aColor) {
  168.         if (debugLog()) {
  169.             info().log(toShortString() + " Setting color: " + aColor);
  170.         }
  171.         graphics.setColor(aColor);
  172.     }
  173.  
  174.     /** Returns the Color used for text drawing operations.
  175.       * @see #setColor
  176.       */
  177.     public Color getColor() {
  178.         return graphics.getColor();
  179.     }
  180.  
  181.     public FontMetrics getFontMetrics() {
  182.         return graphics.getFontMetrics();
  183.     }
  184.  
  185.     public FontMetrics getFontMetrics(Font f) {
  186.         return graphics.getFontMetrics(f);
  187.     }
  188.  
  189.     public void translate(int x, int y) {
  190.         if (debugLog()) {
  191.             info().log(toShortString() +
  192.                 " Translating by: " + new Point(x, y));
  193.         }
  194.         xOffset += x;
  195.         yOffset += y;
  196.         graphics.translate(x, y);
  197.     }
  198.  
  199.     public void setPaintMode() {
  200.         if (debugLog()) {
  201.             info().log(toShortString() + " Setting paint mode");
  202.         }
  203.         graphics.setPaintMode();
  204.     }
  205.  
  206.     public void setXORMode(Color aColor) {
  207.         if (debugLog()) {
  208.             info().log(toShortString() + " Setting XOR mode: " + aColor);
  209.         }
  210.         graphics.setXORMode(aColor);
  211.     }
  212.  
  213.     public Rectangle getClipBounds() {
  214.         return graphics.getClipBounds();
  215.     }
  216.  
  217.     public void clipRect(int x, int y, int width, int height) {
  218.         graphics.clipRect(x, y, width, height);
  219.         if (debugLog()) {
  220.             info().log(toShortString() +
  221.                 " Setting clipRect: " + (new Rectangle(x, y, width, height)) +
  222.                 " New clipRect: " + graphics.getClip());
  223.         }
  224.     }
  225.  
  226.     public void setClip(int x, int y, int width, int height) {
  227.         graphics.setClip(x, y, width, height);
  228.         if (debugLog()) {
  229.             info().log(toShortString() +
  230.                         " Setting new clipRect: " + graphics.getClip());
  231.         }
  232.     }
  233.  
  234.     public Shape getClip() {
  235.         return graphics.getClip();
  236.     }
  237.  
  238.     public void setClip(Shape clip) {
  239.         graphics.setClip(clip);
  240.         if (debugLog()) {
  241.             info().log(toShortString() +
  242.                        " Setting new clipRect: " +  graphics.getClip());
  243.         }
  244.     }
  245.  
  246.     public void drawRect(int x, int y, int width, int height) {
  247.         DebugGraphicsInfo info = info();
  248.  
  249.         if (debugLog()) {
  250.             info().log(toShortString() +
  251.                       " Drawing rect: " +
  252.                       new Rectangle(x, y, width, height));
  253.         }
  254.  
  255.         if (isDrawingBuffer()) {
  256.             if (debugBuffered()) {
  257.                 Graphics debugGraphics = debugGraphics();
  258.  
  259.                 debugGraphics.drawRect(x, y, width, height);
  260.                 debugGraphics.dispose();
  261.             }
  262.         } else if (debugFlash()) {
  263.             Color oldColor = getColor();
  264.             int i, count = (info.flashCount * 2) - 1;
  265.  
  266.             for (i = 0; i < count; i++) {
  267.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  268.                 graphics.drawRect(x, y, width, height);
  269.                 Toolkit.getDefaultToolkit().sync();
  270.                 sleep(info.flashTime);
  271.             }
  272.             graphics.setColor(oldColor);
  273.         }
  274.         graphics.drawRect(x, y, width, height);
  275.     }
  276.  
  277.     public void fillRect(int x, int y, int width, int height) {
  278.         DebugGraphicsInfo info = info();
  279.  
  280.         if (debugLog()) {
  281.             info().log(toShortString() +
  282.                       " Filling rect: " +
  283.                       new Rectangle(x, y, width, height));
  284.         }
  285.  
  286.         if (isDrawingBuffer()) {
  287.             if (debugBuffered()) {
  288.                 Graphics debugGraphics = debugGraphics();
  289.  
  290.                 debugGraphics.fillRect(x, y, width, height);
  291.                 debugGraphics.dispose();
  292.             }
  293.         } else if (debugFlash()) {
  294.             Color oldColor = getColor();
  295.             int i, count = (info.flashCount * 2) - 1;
  296.  
  297.             for (i = 0; i < count; i++) {
  298.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  299.                 graphics.fillRect(x, y, width, height);
  300.                 Toolkit.getDefaultToolkit().sync();
  301.                 sleep(info.flashTime);
  302.             }
  303.             graphics.setColor(oldColor);
  304.         }
  305.         graphics.fillRect(x, y, width, height);
  306.     }
  307.  
  308.     public void clearRect(int x, int y, int width, int height) {
  309.         DebugGraphicsInfo info = info();
  310.  
  311.         if (debugLog()) {
  312.             info().log(toShortString() +
  313.                       " Clearing rect: " +
  314.                       new Rectangle(x, y, width, height));
  315.         }
  316.  
  317.         if (isDrawingBuffer()) {
  318.             if (debugBuffered()) {
  319.                 Graphics debugGraphics = debugGraphics();
  320.  
  321.                 debugGraphics.clearRect(x, y, width, height);
  322.                 debugGraphics.dispose();
  323.             }
  324.         } else if (debugFlash()) {
  325.             Color oldColor = getColor();
  326.             int i, count = (info.flashCount * 2) - 1;
  327.  
  328.             for (i = 0; i < count; i++) {
  329.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  330.                 graphics.clearRect(x, y, width, height);
  331.                 Toolkit.getDefaultToolkit().sync();
  332.                 sleep(info.flashTime);
  333.             }
  334.             graphics.setColor(oldColor);
  335.         }
  336.         graphics.clearRect(x, y, width, height);
  337.     }
  338.  
  339.     public void drawRoundRect(int x, int y, int width, int height,
  340.                               int arcWidth, int arcHeight) {
  341.         DebugGraphicsInfo info = info();
  342.  
  343.         if (debugLog()) {
  344.             info().log(toShortString() +
  345.                       " Drawing round rect: " +
  346.                       new Rectangle(x, y, width, height) +
  347.                       " arcWidth: " + arcWidth +
  348.                       " archHeight: " + arcHeight);
  349.         }
  350.         if (isDrawingBuffer()) {
  351.             if (debugBuffered()) {
  352.                 Graphics debugGraphics = debugGraphics();
  353.  
  354.                 debugGraphics.drawRoundRect(x, y, width, height,
  355.                                             arcWidth, arcHeight);
  356.                 debugGraphics.dispose();
  357.             }
  358.         } else if (debugFlash()) {
  359.             Color oldColor = getColor();
  360.             int i, count = (info.flashCount * 2) - 1;
  361.  
  362.             for (i = 0; i < count; i++) {
  363.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  364.                 graphics.drawRoundRect(x, y, width, height,
  365.                                        arcWidth, arcHeight);
  366.                 Toolkit.getDefaultToolkit().sync();
  367.                 sleep(info.flashTime);
  368.             }
  369.             graphics.setColor(oldColor);
  370.         }
  371.         graphics.drawRoundRect(x, y, width, height, arcWidth, arcHeight);
  372.     }
  373.  
  374.     public void fillRoundRect(int x, int y, int width, int height,
  375.                               int arcWidth, int arcHeight) {
  376.         DebugGraphicsInfo info = info();
  377.  
  378.         if (debugLog()) {
  379.             info().log(toShortString() +
  380.                       " Filling round rect: " +
  381.                       new Rectangle(x, y, width, height) +
  382.                       " arcWidth: " + arcWidth +
  383.                       " archHeight: " + arcHeight);
  384.         }
  385.         if (isDrawingBuffer()) {
  386.             if (debugBuffered()) {
  387.                 Graphics debugGraphics = debugGraphics();
  388.  
  389.                 debugGraphics.fillRoundRect(x, y, width, height,
  390.                                             arcWidth, arcHeight);
  391.                 debugGraphics.dispose();
  392.             }
  393.         } else if (debugFlash()) {
  394.             Color oldColor = getColor();
  395.             int i, count = (info.flashCount * 2) - 1;
  396.  
  397.             for (i = 0; i < count; i++) {
  398.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  399.                 graphics.fillRoundRect(x, y, width, height,
  400.                                        arcWidth, arcHeight);
  401.                 Toolkit.getDefaultToolkit().sync();
  402.                 sleep(info.flashTime);
  403.             }
  404.             graphics.setColor(oldColor);
  405.         }
  406.         graphics.fillRoundRect(x, y, width, height, arcWidth, arcHeight);
  407.     }
  408.  
  409.     public void drawLine(int x1, int y1, int x2, int y2) {
  410.         DebugGraphicsInfo info = info();
  411.  
  412.         if (debugLog()) {
  413.             info().log(toShortString() +
  414.                        " Drawing line: from " + pointToString(x1, y1) +
  415.                        " to " +  pointToString(x2, y2));
  416.         }
  417.  
  418.         if (isDrawingBuffer()) {
  419.             if (debugBuffered()) {
  420.                 Graphics debugGraphics = debugGraphics();
  421.  
  422.                 debugGraphics.drawLine(x1, y1, x2, y2);
  423.                 debugGraphics.dispose();
  424.             }
  425.         } else if (debugFlash()) {
  426.             Color oldColor = getColor();
  427.             int i, count = (info.flashCount * 2) - 1;
  428.  
  429.             for (i = 0; i < count; i++) {
  430.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  431.                 graphics.drawLine(x1, y1, x2, y2);
  432.                 Toolkit.getDefaultToolkit().sync();
  433.                 sleep(info.flashTime);
  434.             }
  435.             graphics.setColor(oldColor);
  436.         }
  437.         graphics.drawLine(x1, y1, x2, y2);
  438.     }
  439.  
  440.     public void draw3DRect(int x, int y, int width, int height,
  441.                            boolean raised) {
  442.         DebugGraphicsInfo info = info();
  443.  
  444.         if (debugLog()) {
  445.             info().log(toShortString() +
  446.                        " Drawing 3D rect: " +
  447.                        new Rectangle(x, y, width, height) +
  448.                        " Raised bezel: " + raised);
  449.         }
  450.         if (isDrawingBuffer()) {
  451.             if (debugBuffered()) {
  452.                 Graphics debugGraphics = debugGraphics();
  453.  
  454.                 debugGraphics.draw3DRect(x, y, width, height, raised);
  455.                 debugGraphics.dispose();
  456.             }
  457.         } else if (debugFlash()) {
  458.             Color oldColor = getColor();
  459.             int i, count = (info.flashCount * 2) - 1;
  460.  
  461.             for (i = 0; i < count; i++) {
  462.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  463.                 graphics.draw3DRect(x, y, width, height, raised);
  464.                 Toolkit.getDefaultToolkit().sync();
  465.                 sleep(info.flashTime);
  466.             }
  467.             graphics.setColor(oldColor);
  468.         }
  469.         graphics.draw3DRect(x, y, width, height, raised);
  470.     }
  471.  
  472.     public void fill3DRect(int x, int y, int width, int height,
  473.                boolean raised) {
  474.         DebugGraphicsInfo info = info();
  475.  
  476.         if (debugLog()) {
  477.             info().log(toShortString() +
  478.                        " Filling 3D rect: " +
  479.                        new Rectangle(x, y, width, height) +
  480.                        " Raised bezel: " + raised);
  481.         }
  482.         if (isDrawingBuffer()) {
  483.             if (debugBuffered()) {
  484.                 Graphics debugGraphics = debugGraphics();
  485.  
  486.                 debugGraphics.fill3DRect(x, y, width, height, raised);
  487.                 debugGraphics.dispose();
  488.             }
  489.         } else if (debugFlash()) {
  490.             Color oldColor = getColor();
  491.             int i, count = (info.flashCount * 2) - 1;
  492.  
  493.             for (i = 0; i < count; i++) {
  494.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  495.                 graphics.fill3DRect(x, y, width, height, raised);
  496.                 Toolkit.getDefaultToolkit().sync();
  497.                 sleep(info.flashTime);
  498.             }
  499.             graphics.setColor(oldColor);
  500.         }
  501.         graphics.fill3DRect(x, y, width, height, raised);
  502.     }
  503.  
  504.     public void drawOval(int x, int y, int width, int height) {
  505.         DebugGraphicsInfo info = info();
  506.  
  507.         if (debugLog()) {
  508.             info().log(toShortString() +
  509.                       " Drawing oval: " +
  510.                       new Rectangle(x, y, width, height));
  511.         }
  512.         if (isDrawingBuffer()) {
  513.             if (debugBuffered()) {
  514.                 Graphics debugGraphics = debugGraphics();
  515.  
  516.                 debugGraphics.drawOval(x, y, width, height);
  517.                 debugGraphics.dispose();
  518.             }
  519.         } else if (debugFlash()) {
  520.             Color oldColor = getColor();
  521.             int i, count = (info.flashCount * 2) - 1;
  522.  
  523.             for (i = 0; i < count; i++) {
  524.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  525.                 graphics.drawOval(x, y, width, height);
  526.                 Toolkit.getDefaultToolkit().sync();
  527.                 sleep(info.flashTime);
  528.             }
  529.             graphics.setColor(oldColor);
  530.         }
  531.         graphics.drawOval(x, y, width, height);
  532.     }
  533.  
  534.     public void fillOval(int x, int y, int width, int height) {
  535.         DebugGraphicsInfo info = info();
  536.  
  537.         if (debugLog()) {
  538.             info().log(toShortString() +
  539.                       " Filling oval: " +
  540.                       new Rectangle(x, y, width, height));
  541.         }
  542.         if (isDrawingBuffer()) {
  543.             if (debugBuffered()) {
  544.                 Graphics debugGraphics = debugGraphics();
  545.  
  546.                 debugGraphics.fillOval(x, y, width, height);
  547.                 debugGraphics.dispose();
  548.             }
  549.         } else if (debugFlash()) {
  550.             Color oldColor = getColor();
  551.             int i, count = (info.flashCount * 2) - 1;
  552.  
  553.             for (i = 0; i < count; i++) {
  554.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  555.                 graphics.fillOval(x, y, width, height);
  556.                 Toolkit.getDefaultToolkit().sync();
  557.                 sleep(info.flashTime);
  558.             }
  559.             graphics.setColor(oldColor);
  560.         }
  561.         graphics.fillOval(x, y, width, height);
  562.     }
  563.  
  564.     public void drawArc(int x, int y, int width, int height,
  565.                         int startAngle, int arcAngle) {
  566.         DebugGraphicsInfo info = info();
  567.  
  568.         if (debugLog()) {
  569.             info().log(toShortString() +
  570.                       " Drawing arc: " +
  571.                       new Rectangle(x, y, width, height) +
  572.                       " startAngle: " + startAngle +
  573.                       " arcAngle: " + arcAngle);
  574.         }
  575.         if (isDrawingBuffer()) {
  576.             if (debugBuffered()) {
  577.                 Graphics debugGraphics = debugGraphics();
  578.  
  579.                 debugGraphics.drawArc(x, y, width, height,
  580.                                       startAngle, arcAngle);
  581.                 debugGraphics.dispose();
  582.             }
  583.         } else if (debugFlash()) {
  584.             Color oldColor = getColor();
  585.             int i, count = (info.flashCount * 2) - 1;
  586.  
  587.             for (i = 0; i < count; i++) {
  588.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  589.                 graphics.drawArc(x, y, width, height, startAngle, arcAngle);
  590.                 Toolkit.getDefaultToolkit().sync();
  591.                 sleep(info.flashTime);
  592.             }
  593.             graphics.setColor(oldColor);
  594.         }
  595.         graphics.drawArc(x, y, width, height, startAngle, arcAngle);
  596.     }
  597.  
  598.     public void fillArc(int x, int y, int width, int height,
  599.                         int startAngle, int arcAngle) {
  600.         DebugGraphicsInfo info = info();
  601.  
  602.         if (debugLog()) {
  603.             info().log(toShortString() +
  604.                       " Filling arc: " +
  605.                       new Rectangle(x, y, width, height) +
  606.                       " startAngle: " + startAngle +
  607.                       " arcAngle: " + arcAngle);
  608.         }
  609.         if (isDrawingBuffer()) {
  610.             if (debugBuffered()) {
  611.                 Graphics debugGraphics = debugGraphics();
  612.  
  613.                 debugGraphics.fillArc(x, y, width, height,
  614.                                       startAngle, arcAngle);
  615.                 debugGraphics.dispose();
  616.             }
  617.         } else if (debugFlash()) {
  618.             Color oldColor = getColor();
  619.             int i, count = (info.flashCount * 2) - 1;
  620.  
  621.             for (i = 0; i < count; i++) {
  622.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  623.                 graphics.fillArc(x, y, width, height, startAngle, arcAngle);
  624.                 Toolkit.getDefaultToolkit().sync();
  625.                 sleep(info.flashTime);
  626.             }
  627.             graphics.setColor(oldColor);
  628.         }
  629.         graphics.fillArc(x, y, width, height, startAngle, arcAngle);
  630.     }
  631.  
  632.     public void drawPolyline(int xPoints[], int yPoints[], int nPoints) {
  633.         DebugGraphicsInfo info = info();
  634.  
  635.         if (debugLog()) {
  636.             info().log(toShortString() +
  637.                       " Drawing polyline: " +
  638.                       " nPoints: " + nPoints +
  639.                       " X's: " + xPoints +
  640.                       " Y's: " + yPoints);
  641.         }
  642.         if (isDrawingBuffer()) {
  643.             if (debugBuffered()) {
  644.                 Graphics debugGraphics = debugGraphics();
  645.  
  646.                 debugGraphics.drawPolyline(xPoints, yPoints, nPoints);
  647.                 debugGraphics.dispose();
  648.             }
  649.         } else if (debugFlash()) {
  650.             Color oldColor = getColor();
  651.             int i, count = (info.flashCount * 2) - 1;
  652.  
  653.             for (i = 0; i < count; i++) {
  654.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  655.                 graphics.drawPolyline(xPoints, yPoints, nPoints);
  656.                 Toolkit.getDefaultToolkit().sync();
  657.                 sleep(info.flashTime);
  658.             }
  659.             graphics.setColor(oldColor);
  660.         }
  661.         graphics.drawPolyline(xPoints, yPoints, nPoints);
  662.     }
  663.  
  664.     public void drawPolygon(int xPoints[], int yPoints[], int nPoints) {
  665.         DebugGraphicsInfo info = info();
  666.  
  667.         if (debugLog()) {
  668.             info().log(toShortString() +
  669.                       " Drawing polygon: " +
  670.                       " nPoints: " + nPoints +
  671.                       " X's: " + xPoints +
  672.                       " Y's: " + yPoints);
  673.         }
  674.         if (isDrawingBuffer()) {
  675.             if (debugBuffered()) {
  676.                 Graphics debugGraphics = debugGraphics();
  677.  
  678.                 debugGraphics.drawPolygon(xPoints, yPoints, nPoints);
  679.                 debugGraphics.dispose();
  680.             }
  681.         } else if (debugFlash()) {
  682.             Color oldColor = getColor();
  683.             int i, count = (info.flashCount * 2) - 1;
  684.  
  685.             for (i = 0; i < count; i++) {
  686.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  687.                 graphics.drawPolygon(xPoints, yPoints, nPoints);
  688.                 Toolkit.getDefaultToolkit().sync();
  689.                 sleep(info.flashTime);
  690.             }
  691.             graphics.setColor(oldColor);
  692.         }
  693.         graphics.drawPolygon(xPoints, yPoints, nPoints);
  694.     }
  695.  
  696.     public void fillPolygon(int xPoints[], int yPoints[], int nPoints) {
  697.         DebugGraphicsInfo info = info();
  698.  
  699.         if (debugLog()) {
  700.             info().log(toShortString() +
  701.                       " Filling polygon: " +
  702.                       " nPoints: " + nPoints +
  703.                       " X's: " + xPoints +
  704.                       " Y's: " + yPoints);
  705.         }
  706.         if (isDrawingBuffer()) {
  707.             if (debugBuffered()) {
  708.                 Graphics debugGraphics = debugGraphics();
  709.  
  710.                 debugGraphics.fillPolygon(xPoints, yPoints, nPoints);
  711.                 debugGraphics.dispose();
  712.             }
  713.         } else if (debugFlash()) {
  714.             Color oldColor = getColor();
  715.             int i, count = (info.flashCount * 2) - 1;
  716.  
  717.             for (i = 0; i < count; i++) {
  718.                 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
  719.                 graphics.fillPolygon(xPoints, yPoints, nPoints);
  720.                 Toolkit.getDefaultToolkit().sync();
  721.                 sleep(info.flashTime);
  722.             }
  723.             graphics.setColor(oldColor);
  724.         }
  725.         graphics.fillPolygon(xPoints, yPoints, nPoints);
  726.     }
  727.  
  728.     public void drawString(String aString, int x, int y) {
  729.         DebugGraphicsInfo info = info();
  730.  
  731.         if (debugLog()) {
  732.             info().log(toShortString() +
  733.                        " Drawing string: \"" + aString +
  734.                        "\" at: " + new Point(x, y));
  735.         }
  736.  
  737.         if (isDrawingBuffer()) {
  738.             if (debugBuffered()) {
  739.                 Graphics debugGraphics = debugGraphics();
  740.  
  741.                 debugGraphics.drawString(aString, x, y);
  742.                 debugGraphics.dispose();
  743.             }
  744.         } else if (debugFlash()) {
  745.             Color oldColor = getColor();
  746.             int i, count = (info.flashCount * 2) - 1;
  747.  
  748.             for (i = 0; i < count; i++) {
  749.                 graphics.setColor((i % 2) == 0 ? info.flashColor
  750.                                   : oldColor);
  751.                 graphics.drawString(aString, x, y);
  752.                 Toolkit.getDefaultToolkit().sync();
  753.                 sleep(info.flashTime);
  754.             }
  755.             graphics.setColor(oldColor);
  756.         }
  757.         graphics.drawString(aString, x, y);
  758.     }
  759.  
  760.     public void drawBytes(byte data[], int offset, int length, int x, int y) {
  761.         DebugGraphicsInfo info = info();
  762.  
  763.         Font font = graphics.getFont();
  764.  
  765.         if (debugLog()) {
  766.             info().log(toShortString() +
  767.                        " Drawing bytes at: " + new Point(x, y));
  768.         }
  769.  
  770.         if (isDrawingBuffer()) {
  771.             if (debugBuffered()) {
  772.                 Graphics debugGraphics = debugGraphics();
  773.  
  774.                 debugGraphics.drawBytes(data, offset, length, x, y);
  775.                 debugGraphics.dispose();
  776.             }
  777.         } else if (debugFlash()) {
  778.             Color oldColor = getColor();
  779.             int i, count = (info.flashCount * 2) - 1;
  780.  
  781.             for (i = 0; i < count; i++) {
  782.                 graphics.setColor((i % 2) == 0 ? info.flashColor
  783.                                   : oldColor);
  784.                 graphics.drawBytes(data, offset, length, x, y);
  785.                 Toolkit.getDefaultToolkit().sync();
  786.                 sleep(info.flashTime);
  787.             }
  788.             graphics.setColor(oldColor);
  789.         }
  790.         graphics.drawBytes(data, offset, length, x, y);
  791.     }
  792.  
  793.     public void drawChars(char data[], int offset, int length, int x, int y) {
  794.         DebugGraphicsInfo info = info();
  795.  
  796.         Font font = graphics.getFont();
  797.  
  798.         if (debugLog()) {
  799.             info().log(toShortString() +
  800.                        " Drawing chars at " +  new Point(x, y));
  801.         }
  802.  
  803.         if (isDrawingBuffer()) {
  804.             if (debugBuffered()) {
  805.                 Graphics debugGraphics = debugGraphics();
  806.  
  807.                 debugGraphics.drawChars(data, offset, length, x, y);
  808.                 debugGraphics.dispose();
  809.             }
  810.         } else if (debugFlash()) {
  811.             Color oldColor = getColor();
  812.             int i, count = (info.flashCount * 2) - 1;
  813.  
  814.             for (i = 0; i < count; i++) {
  815.                 graphics.setColor((i % 2) == 0 ? info.flashColor
  816.                                   : oldColor);
  817.                 graphics.drawChars(data, offset, length, x, y);
  818.                 Toolkit.getDefaultToolkit().sync();
  819.                 sleep(info.flashTime);
  820.             }
  821.             graphics.setColor(oldColor);
  822.         }
  823.         graphics.drawChars(data, offset, length, x, y);
  824.     }
  825.  
  826.     public boolean drawImage(Image img, int x, int y,
  827.                              ImageObserver observer) {
  828.         DebugGraphicsInfo info = info();
  829.  
  830.         if (debugLog()) {
  831.             info().log(toShortString() +
  832.                       " Drawing image: " + img +
  833.                       " at: " + new Point(x, y));
  834.         }
  835.  
  836.         if (isDrawingBuffer()) {
  837.             if (debugBuffered()) {
  838.                 Graphics debugGraphics = debugGraphics();
  839.  
  840.                 debugGraphics.drawImage(img, x, y, observer);
  841.                 debugGraphics.dispose();
  842.             }
  843.         } else if (debugFlash()) {
  844.             int i, count = (info.flashCount * 2) - 1;
  845.             ImageProducer oldProducer = img.getSource();
  846.             ImageProducer newProducer
  847.                 = new FilteredImageSource(oldProducer,
  848.                                 new DebugGraphicsFilter(info.flashColor));
  849.             Image newImage
  850.                 = Toolkit.getDefaultToolkit().createImage(newProducer);
  851.             DebugGraphicsObserver imageObserver
  852.                 = new DebugGraphicsObserver();
  853.  
  854.             for (i = 0; i < count; i++) {
  855.                 graphics.drawImage((i % 2) == 0 ? newImage : img, x, y,
  856.                                    imageObserver);
  857.                 Toolkit.getDefaultToolkit().sync();
  858.                 while (!imageObserver.allBitsPresent() &&
  859.                                        !imageObserver.imageHasProblem()) {
  860.                     sleep(10);
  861.                 }
  862.                 sleep(info.flashTime);
  863.             }
  864.         }
  865.         return graphics.drawImage(img, x, y, observer);
  866.     }
  867.  
  868.     public boolean drawImage(Image img, int x, int y, int width, int height,
  869.                              ImageObserver observer) {
  870.         return graphics.drawImage(img, x, y, width, height, observer);
  871.     }
  872.  
  873.     public boolean drawImage(Image img, int x, int y,
  874.                              Color bgcolor,
  875.                              ImageObserver observer) {
  876.         return graphics.drawImage(img, x, y, bgcolor, observer);
  877.     }
  878.  
  879.     public boolean drawImage(Image img, int x, int y,int width, int height,
  880.                              Color bgcolor,
  881.                              ImageObserver observer) {
  882.         return graphics.drawImage(img, x, y, width, height, bgcolor, observer);
  883.     }
  884.  
  885.     public boolean drawImage(Image img,
  886.                              int dx1, int dy1, int dx2, int dy2,
  887.                              int sx1, int sy1, int sx2, int sy2,
  888.                              ImageObserver observer) {
  889.         return graphics.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2,
  890.                                   observer);
  891.     }
  892.  
  893.     public boolean drawImage(Image img,
  894.                              int dx1, int dy1, int dx2, int dy2,
  895.                              int sx1, int sy1, int sx2, int sy2,
  896.                              Color bgcolor,
  897.                              ImageObserver observer) {
  898.         return graphics.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2,
  899.                                   bgcolor, observer);
  900.     }
  901.  
  902.     public void copyArea(int x, int y, int width, int height,
  903.                          int destX, int destY) {
  904.         if (debugLog()) {
  905.             info().log(toShortString() +
  906.                       " Copying area from: " +
  907.                       new Rectangle(x, y, width, height) +
  908.                       " to: " + new Point(destX, destY));
  909.         }
  910.         graphics.copyArea(x, y, width, height, destX, destY);
  911.     }
  912.  
  913.     final void sleep(int mSecs) {
  914.         try {
  915.             Thread.sleep(mSecs);
  916.         } catch (Exception e) {
  917.         }
  918.     }
  919.  
  920.     public void dispose() {
  921.         graphics.dispose();
  922.         graphics = null;
  923.     }
  924.  
  925.     // ALERT!
  926.     public boolean isDrawingBuffer() {
  927.         return buffer != null;
  928.     }
  929.  
  930.     String toShortString() {
  931.         StringBuffer buffer = new StringBuffer("Graphics" + (isDrawingBuffer() ? "<B>" : "") + "(" + graphicsID + "-" + debugOptions + ")");
  932.         return buffer.toString();
  933.     }
  934.  
  935.     String pointToString(int x, int y) {
  936.         StringBuffer buffer = new StringBuffer("(" + x + ", " + y + ")");
  937.         return buffer.toString();
  938.     }
  939.  
  940.     /** Enables/disables diagnostic information about every graphics
  941.       * operation. The value of <b>options</b> indicates how this information
  942.       * should be displayed. LOG_OPTION causes a text message to be printed.
  943.       * FLASH_OPTION causes the drawing to flash several times. BUFFERED_OPTION
  944.       * creates a new Frame that shows each operation on an
  945.       * offscreen buffer. The value of <b>options</b> is bitwise OR'd into
  946.       * the current value. To disable debugging use NONE_OPTION.
  947.       */
  948.     public void setDebugOptions(int options) {
  949.         if (options != 0) {
  950.             if (options == NONE_OPTION) {
  951.                 if (debugOptions != 0) {
  952.                     System.err.println(toShortString() + " Disabling debug");
  953.                     debugOptions = 0;
  954.                 }
  955.             } else {
  956.                 if (debugOptions != options) {
  957.                     debugOptions |= options;
  958.                     if (debugLog()) {
  959.                         System.err.println(toShortString() + " Enabling debug");
  960.                     }
  961.                 }
  962.             }
  963.         }
  964.     }
  965.  
  966.     /** Returns the current debugging options for this DebugGraphics.
  967.       * @see setDebugOptions
  968.       */
  969.     public int getDebugOptions() {
  970.         return debugOptions;
  971.     }
  972.  
  973.     /** Static wrapper method for DebugGraphicsInfo.setDebugOptions(). Stores
  974.       * options on a per component basis.
  975.       */
  976.     static void setDebugOptions(JComponent component, int options) {
  977.         info().setDebugOptions(component, options);
  978.     }
  979.  
  980.     /** Static wrapper method for DebugGraphicsInfo.getDebugOptions().
  981.       */
  982.     static int getDebugOptions(JComponent component) {
  983.         DebugGraphicsInfo debugGraphicsInfo = info();
  984.         if (debugGraphicsInfo == null) {
  985.             return 0;
  986.         } else {
  987.             return debugGraphicsInfo.getDebugOptions(component);
  988.         }
  989.     }
  990.  
  991.     /** Returns non-zero if <b>component</b> should display with DebugGraphics,
  992.       * zero otherwise. Walks the JComponent's parent tree to determine if
  993.       * any debugging options have been set.
  994.       */
  995.     static int shouldComponentDebug(JComponent component) {
  996.         DebugGraphicsInfo info = info();
  997.         if (info == null) {
  998.             return 0;
  999.         } else {
  1000.             Container container = (Container)component;
  1001.             int debugOptions = 0;
  1002.  
  1003.             while (container != null && (container instanceof JComponent)) {
  1004.                 debugOptions |= info.getDebugOptions((JComponent)container);
  1005.                 container = container.getParent();
  1006.             }
  1007.  
  1008.             return debugOptions;
  1009.         }
  1010.     }
  1011.  
  1012.     /** Returns the number of JComponents that have debugging options turned
  1013.       * on.
  1014.       */
  1015.     static int debugComponentCount() {
  1016.         DebugGraphicsInfo debugGraphicsInfo = info();
  1017.         if (debugGraphicsInfo != null &&
  1018.                     debugGraphicsInfo.componentToDebug != null) {
  1019.             return debugGraphicsInfo.componentToDebug.size();
  1020.         } else {
  1021.             return 0;
  1022.         }
  1023.     }
  1024.  
  1025.     boolean debugLog() {
  1026.         return (debugOptions & LOG_OPTION) == LOG_OPTION;
  1027.     }
  1028.  
  1029.     boolean debugFlash() {
  1030.         return (debugOptions & FLASH_OPTION) == FLASH_OPTION;
  1031.     }
  1032.  
  1033.     boolean debugBuffered() {
  1034.         return (debugOptions & BUFFERED_OPTION) == BUFFERED_OPTION;
  1035.     }
  1036.  
  1037.     /** Returns a DebugGraphics for use in buffering window.
  1038.       */
  1039.     private Graphics debugGraphics() {
  1040.         DebugGraphics        debugGraphics;
  1041.         DebugGraphicsInfo    info = info();
  1042.         JFrame               debugFrame;
  1043.  
  1044.         if (info.debugFrame == null) {
  1045.             info.debugFrame = new JFrame();
  1046.             info.debugFrame.setSize(500, 500);
  1047.         }
  1048.         debugFrame = info.debugFrame;
  1049.         debugFrame.show();
  1050.         debugGraphics = new DebugGraphics(debugFrame.getGraphics());
  1051.         debugGraphics.setFont(getFont());
  1052.         debugGraphics.setColor(getColor());
  1053.         debugGraphics.translate(xOffset, yOffset);
  1054.         debugGraphics.setClip(getClipBounds());
  1055.         if (debugFlash()) {
  1056.             debugGraphics.setDebugOptions(FLASH_OPTION);
  1057.         }
  1058.         return debugGraphics;
  1059.     }
  1060.  
  1061.     /** Returns DebugGraphicsInfo, or creates one if none exists.
  1062.       */
  1063.     static DebugGraphicsInfo info() {
  1064.         DebugGraphicsInfo debugGraphicsInfo = (DebugGraphicsInfo)
  1065.             SwingUtilities.appContextGet(debugGraphicsInfoKey);
  1066.         if (debugGraphicsInfo == null) {
  1067.             debugGraphicsInfo = new DebugGraphicsInfo();
  1068.             SwingUtilities.appContextPut(debugGraphicsInfoKey,
  1069.                                          debugGraphicsInfo);
  1070.         }
  1071.         return debugGraphicsInfo;
  1072.     }
  1073.     private static final Class debugGraphicsInfoKey = DebugGraphicsInfo.class;
  1074. }
  1075.